home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gxclimag.c < prev    next >
Encoding:
C/C++ Source or Header  |  1997-06-15  |  31.6 KB  |  1,039 lines
  1. /* Copyright (C) 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2.   
  3.   This file is part of Aladdin Ghostscript.
  4.   
  5.   Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6.   or distributor accepts any responsibility for the consequences of using it,
  7.   or for whether it serves any particular purpose or works at all, unless he
  8.   or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9.   License (the "License") for full details.
  10.   
  11.   Every copy of Aladdin Ghostscript must include a copy of the License,
  12.   normally in a plain ASCII text file named PUBLIC.  The License grants you
  13.   the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14.   under certain conditions described in the License.  Among other things, the
  15.   License requires that the copyright notice and this notice be preserved on
  16.   all copies.
  17. */
  18.  
  19. /* gxclimag.c */
  20. /* Higher-level image operations for band lists */
  21. #include "math_.h"
  22. #include "memory_.h"
  23. #include "gx.h"
  24. #include "gserrors.h"
  25. #include "gscspace.h"
  26. #include "gxarith.h"
  27. #include "gxdevice.h"
  28. #include "gxdevmem.h"            /* must precede gxcldev.h */
  29. #include "gxcldev.h"
  30. #include "gxclpath.h"
  31. #include "gxfmap.h"
  32. #ifdef FUTURE
  33. #include "strimpl.h"        /* for siscale.h */
  34. #include "siscale.h"
  35. #endif
  36.  
  37. /* Define whether we should use high-level images. */
  38. /* (See below for additional restrictions.) */
  39. static bool USE_HL_IMAGES = true;
  40.  
  41. #define cdev cwdev
  42.  
  43. /* Forward references */
  44. private int cmd_put_color_mapping(P3(gx_device_clist_writer *cldev,
  45.                      const gs_imager_state *pis,
  46.                      bool write_rgb_to_cmyk));
  47.  
  48. /* Driver procedures */
  49. private dev_proc_fill_mask(clist_fill_mask);
  50. private dev_proc_begin_image(clist_begin_image);
  51. private dev_proc_image_data(clist_image_data);
  52. private dev_proc_end_image(clist_end_image);
  53.  
  54. /* Initialize the extensions to the command set. */
  55. void
  56. gs_climag_init(gs_memory_t *mem)
  57. {
  58.     gs_clist_device_procs.fill_mask = clist_fill_mask;
  59.     gs_clist_device_procs.begin_image = clist_begin_image;
  60.     gs_clist_device_procs.image_data = clist_image_data;
  61.     gs_clist_device_procs.end_image = clist_end_image;
  62. }
  63.  
  64. /* ------ Driver procedures ------ */
  65.  
  66. private int
  67. clist_fill_mask(gx_device *dev,
  68.   const byte *data, int data_x, int raster, gx_bitmap_id id,
  69.   int x, int y, int width, int height,
  70.   const gx_drawing_color *pdcolor, int depth,
  71.   gs_logical_operation_t lop, const gx_clip_path *pcpath)
  72. {    const byte *orig_data = data;    /* for writing tile*/
  73.     int orig_data_x = data_x;    /* ditto */
  74.     int orig_x = x;            /* ditto */
  75.     int orig_width = width;        /* ditto */
  76.     int orig_height = height;    /* ditto */
  77.     int log2_depth = depth >> 1;    /* works for 1,2,4 */
  78.     int y0;
  79.     int data_x_bit;
  80.     byte copy_op =
  81.       (depth > 1 ? cmd_op_copy_color_alpha :
  82.        gx_dc_is_pure(pdcolor) ? cmd_op_copy_mono :
  83.        cmd_op_copy_mono + cmd_copy_ht_color);
  84.  
  85.     fit_copy(dev, data, data_x, raster, id, x, y, width, height);
  86.     y0 = y;            /* must do after fit_copy */
  87.     if ( cmd_check_clip_path(cdev, pcpath) )
  88.       cmd_clear_known(cdev, clip_path_known);
  89.     data_x_bit = data_x << log2_depth;
  90.     BEGIN_RECT
  91.     int dx = (data_x_bit & 7) >> log2_depth;
  92.     const byte *row = data + (y - y0) * raster + (data_x_bit >> 3);
  93.     int code;
  94.  
  95.     if ( lop == lop_default )
  96.       { cmd_disable_lop(cdev, pcls);
  97.       }
  98.     else
  99.       { if ( lop != pcls->lop )
  100.           { code = cmd_set_lop(cdev, pcls, lop);
  101.         if ( code < 0 )
  102.           return code;
  103.           }
  104.         cmd_enable_lop(cdev, pcls);
  105.       }
  106.     if ( depth > 1 && !pcls->color_is_alpha )
  107.       { byte *dp;
  108.         set_cmd_put_op(dp, cdev, pcls, cmd_opv_set_copy_alpha, 1);
  109.         pcls->color_is_alpha = 1;
  110.       }
  111.     cmd_do_write_unknown(cdev, pcls, clip_path_known);
  112.     cmd_do_enable_clip(cdev, pcls, pcpath != NULL);
  113.     code = cmd_put_drawing_color(cdev, pcls, pdcolor);
  114.     if ( code < 0 )
  115.       return code;
  116.     /*
  117.      * Unfortunately, painting a character with a halftone requires the
  118.      * use of two bitmaps, a situation that we can neither represent in
  119.      * the band list nor guarantee will both be present in the tile
  120.      * cache; in this case, we always write the bits of the character.
  121.      *
  122.      * We could handle more RasterOp cases here directly, but it
  123.      * doesn't seem worth the trouble right now.
  124.      */
  125.     if ( id != gx_no_bitmap_id && gx_dc_is_pure(pdcolor) &&
  126.          lop == lop_default
  127.        )
  128.       {    /* This is a character.  ****** WRONG IF HALFTONE CELL. ******/
  129.         /* Put it in the cache if possible. */
  130.         ulong offset_temp;
  131.         if ( !cls_has_tile_id(cdev, pcls, id, offset_temp) )
  132.           { gx_strip_bitmap tile;
  133.             tile.data = (byte *)orig_data;    /* actually const */
  134.             tile.raster = raster;
  135.             tile.size.x = tile.rep_width = orig_width;
  136.             tile.size.y = tile.rep_height = orig_height;
  137.             tile.rep_shift = tile.shift = 0;
  138.             tile.id = id;
  139.             if ( clist_change_bits(cdev, pcls, &tile, depth) < 0 )
  140.               { /* Something went wrong; just copy the bits. */
  141.             goto copy;
  142.               }
  143.           }
  144.         { gx_cmd_rect rect;
  145.           int rsize;
  146.           byte op = copy_op + cmd_copy_use_tile;
  147.           byte *dp;
  148.  
  149.           /* Output a command to copy the entire character. */
  150.           /* It will be truncated properly per band. */
  151.           rect.x = orig_x, rect.y = y0;
  152.           rect.width = orig_width, rect.height = yend - y0;
  153.           rsize = 1 + cmd_sizexy(rect);
  154.           if ( orig_data_x )
  155.             { int dx_msb = orig_data_x >> 5;
  156.               set_cmd_put_op(dp, cdev, pcls, cmd_opv_set_misc,
  157.                      2 + cmd_size_w(dx_msb));
  158.               if ( dx_msb )
  159.             { dp[1] = cmd_set_misc_data_x + 0x20 +
  160.                 (orig_data_x & 0x1f);
  161.               cmd_put_w(dx_msb, dp + 2);
  162.             }
  163.               else
  164.             dp[1] = cmd_set_misc_data_x + orig_data_x;
  165.             }
  166.           set_cmd_put_op(dp, cdev, pcls, op, rsize);
  167.           dp++;
  168.           cmd_putxy(rect, dp);
  169.           pcls->rect = rect;
  170.           goto end;
  171.         }
  172.       }
  173. copy:    /*
  174.      * The default fill_mask implementation uses strip_copy_rop;
  175.      * this is exactly what we want.
  176.      */
  177.     code = gx_default_fill_mask(dev, row, dx, raster,
  178.                     (y == y0 && height == orig_height &&
  179.                      dx == orig_data_x ? id :
  180.                      gx_no_bitmap_id),
  181.                     x, y, width, height, pdcolor, depth,
  182.                     lop, NULL);
  183.     if ( code < 0 )
  184.       return code;
  185. end:    ;
  186.     END_RECT
  187.     return 0;
  188. }
  189.  
  190. /* ------ Bitmap image driver procedures ------ */
  191.  
  192. /* Define the structure for keeping track of progress through an image. */
  193. typedef struct clist_image_enum_s {
  194.         /* Arguments of begin_image */
  195.     gs_memory_t *memory;
  196.     gs_image_t image;
  197.     gx_drawing_color dcolor;
  198.     gs_int_rect rect;
  199.     const gs_imager_state *pis;
  200.     const gx_clip_path *pcpath;
  201.         /* Set at creation time */
  202.     void *default_info;
  203. #ifndef FUTURE
  204.       /* NOTE: currently format is always gs_image_format_chunky. */
  205. #endif
  206.     gs_image_format_t format;
  207. #ifndef FUTURE
  208.       /* NOTE: currently support is always (0,0). */
  209. #endif
  210.     gs_int_point support;    /* extra source pixels for interpolation */
  211. #ifndef FUTURE
  212.       /* NOTE: currently num_planes is always 1. */
  213. #endif
  214.     int num_planes;
  215.     int bits_per_plane;    /* bits per pixel per plane */
  216.     gs_matrix matrix;    /* image space -> device space */
  217.     bool uses_color;
  218.     byte color_space;
  219.     int ymin, ymax;
  220.         /* Updated dynamically */
  221.     int y;
  222. } clist_image_enum;
  223. /* We can disregard the pointers in the writer by allocating */
  224. /* the image enumerator as immovable.  This is a hack, of course. */
  225. gs_private_st_ptrs1(st_clist_image_enum, clist_image_enum, "clist_image_enum",
  226.   clist_image_enum_enum_ptrs, clist_image_enum_reloc_ptrs, default_info);
  227.  
  228. /* Forward declarations */
  229. private bool image_band_box(P5(gx_device *dev, const clist_image_enum *pie,
  230.                    int y, int h, gs_int_rect *pbox));
  231. private int cmd_image_data(P9(gx_device_clist_writer *cldev,
  232.                   gx_clist_state *pcls,
  233.                   const byte **planes, int num_planes,
  234.                   uint offset, int data_x, uint raster,
  235.                   uint bytes_per_plane, int h));
  236.  
  237. /*
  238.  * Since currently we are limited to writing a single subrectangle of the
  239.  * image for each band, images that are rotated by angles other than
  240.  * multiples of 90 degrees may wind up writing many copies of the data.
  241.  * Eventually we will fix this by breaking up the image into multiple
  242.  * subrectangles, but for now, don't use the high-level approach if it would
  243.  * cause the data to explode because of this.
  244.  */
  245. private bool
  246. image_matrix_ok_to_band(const gs_matrix *pmat)
  247. {    double t;
  248.     if ( is_xxyy(pmat) || is_xyyx(pmat) )
  249.       return true;
  250.     t = (fabs(pmat->xx) + fabs(pmat->yy)) /
  251.       (fabs(pmat->xy) + fabs(pmat->yx));
  252.     return (t < 0.2 || t > 5);
  253. }
  254.  
  255. /* Start processing an image. */
  256. private int
  257. clist_begin_image(gx_device *dev,
  258.   const gs_imager_state *pis, const gs_image_t *pim,
  259.   gs_image_format_t format, const gs_int_rect *prect,
  260.   const gx_drawing_color *pdcolor, const gx_clip_path *pcpath,
  261.   gs_memory_t *mem, void **pinfo)
  262. {    clist_image_enum *pie;
  263.     int base_index;
  264.     bool indexed;
  265.     int num_components;
  266.     int bits_per_pixel;
  267.     bool uses_color;
  268.     gs_matrix mat;
  269.     int code;
  270.  
  271.     /* See above for why we allocate the enumerator as immovable. */
  272.     pie = gs_alloc_struct_immovable(mem, clist_image_enum,
  273.                     &st_clist_image_enum,
  274.                     "clist_begin_image");
  275.     if ( pie == 0 )
  276.       return_error(gs_error_VMerror);
  277.     pie->memory = mem;
  278.     *pinfo = pie;
  279.     if ( pim->ImageMask )
  280.       { base_index = gs_color_space_index_DeviceGray;  /* arbitrary */
  281.         indexed = false;
  282.         num_components = 1;
  283.         uses_color = true;
  284.       }
  285.     else
  286.       { const gs_color_space *pcs = pim->ColorSpace;
  287.         base_index = gs_color_space_get_index(pcs);
  288.         if ( base_index == gs_color_space_index_Indexed )
  289.           { const gs_color_space *pbcs =
  290.           gs_color_space_indexed_base_space(pcs);
  291.         indexed = true;
  292.         base_index = gs_color_space_get_index(pbcs);
  293.         num_components = 1;
  294.           }
  295.         else
  296.           { indexed = false;
  297.         num_components = gs_color_space_num_components(pcs);
  298.           }
  299.         uses_color = pim->CombineWithColor && rop3_uses_T(pis->log_op);
  300.       }
  301.     if (
  302.          !USE_HL_IMAGES ||        /* Always use the default. */
  303.          cdev->in_image ||        /* Can't handle nested images */
  304.          /****** CAN'T HANDLE CIE COLOR YET ******/
  305.          base_index > gs_color_space_index_DeviceCMYK ||
  306.          /****** CAN'T HANDLE INDEXED COLOR (READING MAP) ******/
  307.          indexed ||
  308.          /****** CAN'T HANDLE NON-PURE COLORS YET ******/
  309.          (uses_color && !gx_dc_is_pure(pdcolor)) ||
  310. #ifdef DPNEXT
  311.          /****** CAN'T HANDLE IMAGES WITH ALPHA YET ******/
  312.          pim->HasAlpha ||
  313. #endif
  314.          (code = gs_matrix_invert(&pim->ImageMatrix, &mat)) < 0 ||
  315.          (code = gs_matrix_multiply(&mat, &ctm_only(pis), &mat)) < 0 ||
  316.          !image_matrix_ok_to_band(&mat) ||
  317. #ifndef FUTURE
  318.          /****** CAN'T HANDLE MULTI-PLANE IMAGES YET ******/
  319.          /****** (requires flipping in cmd_image_data) ******/
  320.          (format != gs_image_format_chunky &&
  321.           (num_components > 1 ||
  322.            (format == gs_image_format_bit_planar &&
  323.         pim->BitsPerComponent > 1))) ||
  324.          /****** CAN'T HANDLE INTERPOLATION YET ******/
  325.          pim->Interpolate ||
  326. #endif
  327.          cmd_put_color_mapping((gx_device_clist_writer *)dev, pis,
  328.                    (dev->color_info.num_components == 4 &&
  329.                     base_index == gs_color_space_index_DeviceRGB)) < 0
  330.        )
  331.         { int code = gx_default_begin_image(dev, pis, pim, format, prect,
  332.                         pdcolor, pcpath, mem,
  333.                         &pie->default_info);
  334.           if ( code < 0 )
  335.         gs_free_object(mem, pie, "clist_begin_image");
  336.           return code;
  337.         }
  338.     bits_per_pixel = pim->BitsPerComponent * num_components;
  339.     pie->default_info = 0;
  340.     pie->image = *pim;
  341.     pie->dcolor = *pdcolor;
  342.     if ( prect )
  343.       pie->rect = *prect;
  344.     else
  345.       { pie->rect.p.x = 0, pie->rect.p.y = 0;
  346.         pie->rect.q.x = pim->Width, pie->rect.q.y = pim->Height;
  347.       }
  348.     pie->pis = pis;
  349.     pie->pcpath = pcpath;
  350.     pie->format = format;
  351.     switch ( format )
  352.       {
  353.       case gs_image_format_chunky:
  354.         pie->num_planes = 1; break;
  355.       case gs_image_format_component_planar:
  356.         pie->num_planes = num_components; break;
  357.       case gs_image_format_bit_planar:
  358.         pie->num_planes = bits_per_pixel; break;
  359.       }
  360.     pie->bits_per_plane = bits_per_pixel / pie->num_planes;
  361.     pie->matrix = mat;
  362.     pie->uses_color = uses_color;
  363.     pie->color_space = (base_index << 4) |
  364.       (indexed ? (pim->ColorSpace->params.indexed.use_proc ? 12 : 8) : 0);
  365.     pie->y = pie->rect.p.y;
  366.  
  367.     /*
  368.      * Make sure the CTM, color space, and clipping region (and, for
  369.      * masked images or images with CombineWithColor, the current color)
  370.      * are known at the time of the begin_image command.
  371.      */
  372.  
  373.     { uint unknown = 0;
  374.       if ( state_neq(ctm.xx) || state_neq(ctm.xy) ||
  375.            state_neq(ctm.yx) || state_neq(ctm.yy) ||
  376.            state_neq(ctm.tx) || state_neq(ctm.ty)
  377.          )
  378.         { unknown |= ctm_known;
  379.           state_update(ctm);
  380.         }
  381.       /****** hival CHECK IS NOT SUFFICIENT ******/
  382.       if ( cdev->color_space != pie->color_space ||
  383.            ((cdev->color_space & 8) != 0 &&
  384.         cdev->indexed_params.hival !=
  385.         pie->image.ColorSpace->params.indexed.hival)
  386.          )
  387.         { unknown |= color_space_known;
  388.           cdev->color_space = pie->color_space;
  389.           if ( cdev->color_space & 8 )
  390.         cdev->indexed_params = pie->image.ColorSpace->params.indexed;
  391.         }
  392.       if ( cmd_check_clip_path(cdev, pcpath) )
  393.         unknown |= clip_path_known;
  394.       if ( unknown )
  395.         cmd_clear_known(cdev, unknown);
  396.     }
  397.  
  398.     /* Write out the begin_image command(s). */
  399.  
  400.     { gs_rect sbox, dbox;
  401.       int y, height;
  402.       byte cbuf[3 + 2 * cmd_sizew_max + 14 * sizeof(float) +
  403.               4 * cmd_sizew_max];
  404.       byte *cp = cbuf;
  405.       byte b;
  406. #ifdef FUTURE
  407.       byte b2 = 0;
  408. #endif
  409.  
  410.       /* Construct the begin_image command. */
  411.  
  412.       cmd_put2w(pim->Width, pim->Height, cp);
  413.       if ( pim->ImageMask )
  414.         b = 0;
  415.       else switch ( pim->BitsPerComponent )
  416.         {
  417.         case 1: b = 1 << 5; break;
  418.         case 2: b = 2 << 5; break;
  419.         case 4: b = 3 << 5; break;
  420.         case 8: b = 4 << 5; break;
  421.         case 12: b = 5 << 5; break;
  422.         default: return_error(gs_error_rangecheck);
  423.         }
  424. #ifdef FUTURE
  425.       if ( format != gs_image_format_chunky )
  426.         b |= 1 << 4,
  427.           b2 |= format << 6;
  428.       if ( pim->Interpolate )
  429.         { b |= 1 << 4;
  430.           b2 |= 1 << 5;
  431.           pie->support.x = pie->support.y = max_support + 1;
  432.         }
  433.       else
  434.         pie->support.x = pie->support.y = 0;
  435. #else
  436.       if ( pim->Interpolate )
  437.         b |= 1 << 4;
  438.       pie->support.x = pie->support.y = 0;
  439. #endif
  440.       if ( !(pim->ImageMatrix.xx == pim->Width &&
  441.          pim->ImageMatrix.xy == 0 &&
  442.          pim->ImageMatrix.yx == 0 &&
  443.          pim->ImageMatrix.yy == -pim->Height &&
  444.          pim->ImageMatrix.tx == 0 &&
  445.          pim->ImageMatrix.ty == pim->Height
  446.         )
  447.          )
  448.         { b |= 1 << 3;
  449.           cp = cmd_for_matrix(cp, &pim->ImageMatrix);
  450.         }
  451.       { static const float base_decode[8] = {0, 1, 0, 1, 0, 1, 0, 1};
  452.         float indexed_decode[2];
  453.         const float *default_decode = base_decode;
  454.         int num_decode = num_components * 2;
  455.         int i;
  456.  
  457.         if ( indexed )
  458.           { indexed_decode[0] = 0;
  459.         indexed_decode[1] = (1 << pim->BitsPerComponent) - 1;
  460.         default_decode = indexed_decode;
  461.           }
  462.         for ( i = 0; i < num_decode; ++i )
  463.           if ( pim->Decode[i] != default_decode[i] )
  464.         break;
  465.         if ( i != num_decode )
  466.           { byte *pdb = cp++;
  467.         byte dflags = 0;
  468.  
  469.         b |= 1 << 2;
  470.         for ( i = 0; i < num_decode; i += 2 )
  471.           { float u = pim->Decode[i], v = pim->Decode[i+1];
  472.             dflags <<= 2;
  473.             if ( u == 0 && v == default_decode[i+1] )
  474.               ;
  475.             else if ( u == default_decode[i+1] && v == 0 )
  476.               dflags += 1;
  477.             else
  478.               { if ( u != 0 )
  479.               { dflags++;
  480.                 memcpy(cp, &u, sizeof(float));
  481.                 cp += sizeof(float);
  482.               }
  483.             dflags += 2;
  484.             memcpy(cp, &v, sizeof(float));
  485.             cp += sizeof(float);
  486.               }
  487.           }
  488.         *pdb = dflags << (8 - num_decode);
  489.           }
  490.       }
  491.       if ( (pim->ImageMask ? pim->adjust : pim->CombineWithColor) )
  492.         b |= 1 << 1;
  493.       sbox.p.x = pie->rect.p.x;
  494.       sbox.p.y = pie->rect.p.y;
  495.       sbox.q.x = pie->rect.q.x;
  496.       sbox.q.y = pie->rect.q.y;
  497.       gs_bbox_transform(&sbox, &pie->matrix, &dbox);
  498.       { int y0 = (int)floor(dbox.p.y - 0.01);    /* rounding slop */
  499.         int y1 = (int)ceil(dbox.q.y + 0.01);    /* ditto */
  500.  
  501.         y = pie->ymin = max(y0, 0);
  502.         height = (pie->ymax = min(y1, dev->height)) - y;
  503.       }
  504.             
  505.       /* Write a begin_image command in every affected band. */
  506.  
  507.       BEGIN_RECT
  508.       gs_logical_operation_t lop = pis->log_op;
  509.       byte *dp;
  510.       gs_int_rect ibox;
  511.       byte *bp = cp;
  512.       byte cb = b;
  513. #ifdef FUTURE
  514.       uint clen = (b & (1 << 4) ? 3 : 2);
  515. #else
  516.       uint clen = 2;
  517. #endif
  518.       uint len, total_len;
  519.  
  520.       /* If the intersection is empty, skip this band. */
  521.       if ( !image_band_box(dev, pie, y, height, &ibox) )
  522.         continue;
  523.  
  524.       /* Make sure the imager state is up to date. */
  525.       cmd_do_write_unknown(cdev, pcls,
  526.                    ctm_known | clip_path_known | color_space_known);
  527.       cmd_do_enable_clip(cdev, pcls, pcpath != NULL);
  528.       if ( lop == lop_default )
  529.         { cmd_disable_lop(cdev, pcls);
  530.         }
  531.       else
  532.         { if ( lop != pcls->lop )
  533.             { code = cmd_set_lop(cdev, pcls, lop);
  534.               if ( code < 0 )
  535.             return code;
  536.         }
  537.           cmd_enable_lop(cdev, pcls);
  538.         }
  539.       if ( pie->uses_color )
  540.         { code = cmd_put_drawing_color(cdev, pcls, &pie->dcolor);
  541.           if ( code < 0 )
  542.         return code;
  543.         }
  544.       if ( ibox.p.x != 0 || ibox.p.y != 0 ||
  545.            ibox.q.x != pim->Width || ibox.q.y != pim->Height
  546.          )
  547.         { cb |= 1 << 0;
  548.           cmd_put2w(ibox.p.x, ibox.p.y, bp);
  549.           cmd_put2w(pim->Width - ibox.q.x, pim->Height - ibox.q.y, bp);
  550.         }
  551.       len = bp - cbuf;
  552.       total_len = clen + len;
  553.       set_cmd_put_op(dp, cdev, pcls, cmd_opv_begin_image, total_len);
  554.       dp[1] = cb;
  555. #ifdef FUTURE
  556.       dp[2] = b2;
  557. #endif
  558.       dp += clen;
  559.       memcpy(dp, cbuf, len);
  560.       END_RECT
  561.     }
  562.     cdev->in_image = true;
  563.     return 0;
  564. }
  565.  
  566. /* Process the next piece of an image. */
  567. private int
  568. clist_image_data(gx_device *dev,
  569.   void *info, const byte **planes, int data_x, uint raster, int yh)
  570. {    clist_image_enum *pie = info;
  571.     gs_rect sbox, dbox;
  572.     int y0, y1;
  573.     int y, height;        /* for BEGIN/END_RECT */
  574.  
  575.     if ( pie->default_info )
  576.       return gx_default_image_data(dev, pie->default_info, planes, data_x,
  577.                        raster, yh);
  578.     sbox.p.x = pie->rect.p.x;
  579.     sbox.p.y = y0 = pie->y;
  580.     sbox.q.x = pie->rect.q.x;
  581.     sbox.q.y = y1 = pie->y += yh;
  582.     gs_bbox_transform(&sbox, &pie->matrix, &dbox);
  583.     /*
  584.      * In order to keep the band list consistent, we must write out
  585.      * the image data in precisely those bands whose begin_image
  586.      * Y range includes the respective image scan lines.  Because of
  587.      * rounding, we must expand the dbox by a little extra, and then
  588.      * use image_band_box to calculate the precise range for each band.
  589.      * This is slow, but we don't see any faster way to do it in the
  590.      * general case.
  591.      */
  592.     { int ry0 = (int)floor(dbox.p.y) - 2;
  593.       int ry1 = (int)ceil(dbox.q.y) + 2;
  594.       int band_height = cdev->page_band_height;
  595.  
  596.       y = max(ry0, 0) / band_height * band_height;
  597.       height = min(round_up(ry1, band_height), dev->height) - y;
  598.     }
  599.  
  600.     BEGIN_RECT
  601.     int code;
  602.     
  603.     { /*
  604.        * Just transmit the subset of the data that intersects this band.
  605.        * Note that y and height always define a complete band.
  606.        */
  607.       gs_int_rect ibox;
  608. #define bx0 ibox.p.x
  609. #define by0 ibox.p.y
  610. #define bx1 ibox.q.x
  611. #define by1 ibox.q.y
  612.       int bpp = pie->bits_per_plane;
  613.       uint offset;
  614.       int iy, ih, xskip, nrows;
  615.       uint bytes_per_plane, bytes_per_row, rows_per_cmd;
  616.  
  617.       if ( !image_band_box(dev, pie, y, height, &ibox) )
  618.         continue;
  619.       if ( by0 < y0 )
  620.         by0 = y0;
  621.       if ( by1 > y1 )
  622.         by1 = y1;
  623.       offset = (by0 - y0) * raster;
  624.       /*
  625.        * Make sure we're skipping an integral number of pixels, by
  626.        * truncating the initial X coordinate to the next lower
  627.        * value that is an exact multiple of a byte.
  628.        */
  629.       xskip = bx0 & -(int)"\001\010\004\010\002\010\004\010"[bpp & 7];
  630.       offset += (xskip * bpp) >> 3;
  631.       xskip = bx0 - xskip;
  632.       bytes_per_plane = ((xskip + bx1 - bx0) * bpp + 7) >> 3;
  633.       bytes_per_row = bytes_per_plane * pie->num_planes;
  634.       rows_per_cmd =
  635.         (cbuf_size - cmd_largest_size) / max(bytes_per_row, 1);
  636.  
  637.       if ( rows_per_cmd == 0 )
  638.         { /* The reader will have to buffer a row separately. */
  639.           rows_per_cmd = 1;
  640.         }
  641.       for ( iy = by0, ih = by1 - by0; ih > 0;
  642.         iy += nrows, ih -= nrows, offset += raster * nrows
  643.           )
  644.         { nrows = min(ih, rows_per_cmd);
  645.           code = cmd_image_data(cdev, pcls, planes, pie->num_planes,
  646.                     offset, data_x + xskip, raster,
  647.                     bytes_per_plane, nrows);
  648.           if ( code < 0 )
  649.         return code;
  650.         }
  651. #undef bx0
  652. #undef by0
  653. #undef bx1
  654. #undef by1
  655.     }
  656.  
  657.     END_RECT
  658.     return pie->y >= pie->rect.q.y;
  659. }
  660.  
  661. /* Clean up by releasing the buffers. */
  662. private int
  663. clist_end_image(gx_device *dev, void *info, bool draw_last)
  664. {    clist_image_enum *pie = info;
  665.     int code;
  666.  
  667.     if ( pie->default_info )
  668.       code = gx_default_end_image(dev, pie->default_info, draw_last);
  669.     else
  670.       { int y = pie->ymin;
  671.         int height = pie->ymax - y;
  672.         BEGIN_RECT
  673.           gs_int_rect ibox;
  674.           byte *dp;
  675.  
  676.           if ( !image_band_box(dev, pie, y, height, &ibox) )
  677.         continue;
  678.           set_cmd_put_op(dp, cdev, pcls, cmd_opv_image_data, 2);
  679.           dp[1] = 0;        /* EOD */
  680.         END_RECT
  681.         code = 0;
  682.         cdev->in_image = false;
  683.       }
  684.     gs_free_object(pie->memory, pie, "clist_end_image");
  685.     return code;
  686. }
  687.  
  688. /* ------ Utilities ------ */
  689.  
  690. /* Add commands to represent a halftone order. */
  691. private int
  692. cmd_put_ht_order(gx_device_clist_writer *cldev, const gx_ht_order *porder,
  693.   gs_ht_separation_name cname,
  694.   int component /* -1 = default/gray/black screen */)
  695. {    byte command[cmd_max_intsize(sizeof(long)) * 8];
  696.     byte *cp;
  697.     uint len;
  698.     byte *dp;
  699.     uint i, n;
  700.  
  701.     /* Put out the order parameters. */
  702.     cp = cmd_put_w(component + 1, command);
  703.     if ( component >= 0 )
  704.       cp = cmd_put_w(cname, cp);
  705.     cp = cmd_put_w(porder->width, cp);
  706.     cp = cmd_put_w(porder->height, cp);
  707.     cp = cmd_put_w(porder->raster, cp);
  708.     cp = cmd_put_w(porder->shift, cp);
  709.     cp = cmd_put_w(porder->num_levels, cp);
  710.     cp = cmd_put_w(porder->num_bits, cp);
  711.     len = cp - command;
  712.     set_cmd_put_all_op(dp, cldev, cmd_opv_set_ht_order, len + 1);
  713.     memcpy(dp + 1, command, len);
  714.  
  715.     /* Put out the transfer function, if any. */
  716.     cmd_put_color_map(cldev, cmd_map_ht_transfer, porder->transfer,
  717.               NULL);
  718.  
  719.     /* Put out the levels array. */
  720. #define nlevels min((cbuf_size - 2) / sizeof(*porder->levels), 255)
  721.     for ( i = 0; i < porder->num_levels; i += n )
  722.       { n = porder->num_levels - i;
  723.         if ( n > nlevels )
  724.           n = nlevels;
  725.         set_cmd_put_all_op(dp, cldev, cmd_opv_set_ht_data,
  726.                    2 + n * sizeof(*porder->levels));
  727.         dp[1] = n;
  728.         memcpy(dp + 2, porder->levels + i, n * sizeof(*porder->levels));
  729.       }
  730. #undef nlevels
  731.  
  732.     /* Put out the bits array. */
  733. #define nbits min((cbuf_size - 2) / sizeof(*porder->bits), 255)
  734.     for ( i = 0; i < porder->num_bits; i += n )
  735.       { n = porder->num_bits - i;
  736.         if ( n > nbits )
  737.           n = nbits;
  738.         set_cmd_put_all_op(dp, cldev, cmd_opv_set_ht_data,
  739.                    2 + n * sizeof(*porder->bits));
  740.         dp[1] = n;
  741.         memcpy(dp + 2, porder->bits + i, n * sizeof(*porder->bits));
  742.       }
  743. #undef nbits
  744.  
  745.     return 0;
  746. }
  747.  
  748. /* Add commands to represent a full (device) halftone. */
  749. /* We put out the default/gray/black screen last so that the reading */
  750. /* pass can recognize the end of the halftone. */
  751. int
  752. cmd_put_halftone(gx_device_clist_writer *cldev, const gx_device_halftone *pdht,
  753.   gs_halftone_type type)
  754. {    uint num_comp = (pdht->components == 0 ? 0 : pdht->num_comp);
  755.  
  756.     { byte *dp;
  757.  
  758.       set_cmd_put_all_op(dp, cldev, cmd_opv_set_misc,
  759.                  2 + cmd_size_w(num_comp));
  760.       dp[1] = cmd_set_misc_halftone + type;
  761.       cmd_put_w(num_comp, dp + 2);
  762.     }
  763.     if ( num_comp == 0 )
  764.       return cmd_put_ht_order(cldev, &pdht->order,
  765.                   gs_ht_separation_Default, -1);
  766.     { int i;
  767.  
  768.       for ( i = num_comp; --i >= 0; )
  769.         { int code = cmd_put_ht_order(cldev, &pdht->components[i].corder,
  770.                       pdht->components[i].cname, i);
  771.           if ( code < 0 )
  772.         return code;
  773.         }
  774.     }
  775.     return 0;
  776. }
  777.  
  778. /* Write out any necessary color mapping data. */
  779. private int
  780. cmd_put_color_mapping(gx_device_clist_writer *cldev,
  781.   const gs_imager_state *pis, bool write_rgb_to_cmyk)
  782. {    int code;
  783.     const gx_device_halftone *pdht = pis->dev_ht;
  784.  
  785.     /* Put out the halftone. */
  786.     if ( pdht->id != cldev->device_halftone_id )
  787.       { code = cmd_put_halftone(cldev, pdht, pis->halftone->type);
  788.         if ( code < 0 )
  789.           return code;
  790.         cldev->device_halftone_id = pdht->id;
  791.       }
  792.  
  793.     /* If we need to map RGB to CMYK, put out b.g. and u.c.r. */
  794.     if ( write_rgb_to_cmyk )
  795.       { code = cmd_put_color_map(cldev, cmd_map_black_generation,
  796.                      pis->black_generation,
  797.                      &cldev->black_generation_id);
  798.         if ( code < 0 )
  799.           return code;
  800.         code = cmd_put_color_map(cldev, cmd_map_undercolor_removal,
  801.                      pis->undercolor_removal,
  802.                      &cldev->undercolor_removal_id);
  803.         if ( code < 0 )
  804.           return code;
  805.       }
  806.  
  807.     /* Now put out the transfer functions. */
  808.     { uint which = 0;
  809.       bool all_same = true;
  810.       int i;
  811.  
  812.       for ( i = 0; i < countof(cldev->transfer_ids); ++i )
  813.         { if ( pis->effective_transfer.indexed[i]->id !=
  814.            cldev->transfer_ids[i]
  815.          )
  816.             which |= 1 << i;
  817.           if ( pis->effective_transfer.indexed[i]->id !=
  818.            pis->effective_transfer.indexed[0]->id
  819.          )
  820.         all_same = false;
  821.         }
  822.       /* There are 3 cases for transfer functions: nothing to write, */
  823.       /* a single function, and multiple functions. */
  824.       if ( which == 0 )
  825.         return 0;
  826.       if ( which == (1 << countof(cldev->transfer_ids)) - 1 && all_same )
  827.         { code = cmd_put_color_map(cldev, cmd_map_transfer,
  828.                        pis->effective_transfer.indexed[0],
  829.                        &cldev->transfer_ids[0]);
  830.           if ( code < 0 )
  831.         return code;
  832.           for ( i = 1; i < countof(cldev->transfer_ids); ++i )
  833.         cldev->transfer_ids[i] = cldev->transfer_ids[0];
  834.         }
  835.       else
  836.         for ( i = 0; i < countof(cldev->transfer_ids); ++i )
  837.           { code = cmd_put_color_map(cldev,
  838.                 (cmd_map_index)(cmd_map_transfer_0 + i),
  839.                 pis->effective_transfer.indexed[i],
  840.                 &cldev->transfer_ids[i]);
  841.             if ( code < 0 )
  842.           return code;
  843.           }
  844.     }
  845.  
  846.     return 0;
  847. }
  848.  
  849. /*
  850.  * Compute the subrectangle of an image that intersects a band;
  851.  * return false if it is empty.
  852.  * It is OK for this to be too large; in fact, with the present
  853.  * algorithm, it will be quite a bit too large if the transformation isn't
  854.  * well-behaved ("well-behaved" meaning either xy = yx = 0 or xx = yy = 0).
  855.  */
  856. private void
  857. box_merge_point(gs_int_rect *pbox, floatp x, floatp y)
  858. {    int t;
  859.  
  860.     if ( (t = (int)floor(x)) < pbox->p.x )
  861.       pbox->p.x = t;
  862.     if ( (t = (int)ceil(x)) > pbox->q.x )
  863.       pbox->q.x = t;
  864.     if ( (t = (int)floor(y)) < pbox->p.y )
  865.       pbox->p.y = t;
  866.     if ( (t = (int)ceil(y)) > pbox->q.y )
  867.       pbox->q.y = t;
  868. }
  869. private bool
  870. image_band_box(gx_device *dev, const clist_image_enum *pie, int y, int h,
  871.   gs_int_rect *pbox)
  872. {    fixed by0 = int2fixed(y);
  873.     fixed by1 = int2fixed(y + h);
  874.     int px = pie->rect.p.x, py = pie->rect.p.y,
  875.       qx = pie->rect.q.x, qy = pie->rect.q.y;
  876.     gs_fixed_rect cbox;    /* device clipping box */
  877.     gs_rect bbox;        /* cbox intersected with band */
  878.  
  879.     /* Intersect the device clipping box and the band. */
  880.     (*dev_proc(dev, get_clipping_box))(dev, &cbox);
  881.     /* The fixed_half here is to allow for adjustment. */
  882.     bbox.p.x = fixed2float(cbox.p.x - fixed_half);
  883.     bbox.q.x = fixed2float(cbox.q.x + fixed_half);
  884.     bbox.p.y = fixed2float(max(cbox.p.y, by0) - fixed_half);
  885.     bbox.q.y = fixed2float(min(cbox.q.y, by1) + fixed_half);
  886. #ifdef DEBUG
  887.     if ( gs_debug_c('b') )
  888.       { dprintf6("[b]band box for (%d,%d),(%d,%d), band (%d,%d) =>\n",
  889.               px, py, qx, qy, y, y + h);
  890.         dprintf10("      (%g,%g),(%g,%g), matrix=[%g %g %g %g %g %g]\n",
  891.               bbox.p.x, bbox.p.y, bbox.q.x, bbox.q.y,
  892.               pie->matrix.xx, pie->matrix.xy, pie->matrix.yx,
  893.               pie->matrix.yy, pie->matrix.tx, pie->matrix.ty);
  894.       }
  895. #endif
  896.     if ( is_xxyy(&pie->matrix) || is_xyyx(&pie->matrix) )
  897.       { /*
  898.          * The inverse transform of the band is a rectangle aligned with
  899.          * the coordinate axes, so we can just intersect it with the
  900.          * image subrectangle.
  901.          */
  902.         gs_rect ibox;    /* bbox transformed back to image space */
  903.  
  904.         gs_bbox_transform_inverse(&bbox, &pie->matrix, &ibox);
  905.         pbox->p.x = max(px, (int)floor(ibox.p.x));
  906.         pbox->q.x = min(qx, (int)ceil(ibox.q.x));
  907.         pbox->p.y = max(py, (int)floor(ibox.p.y));
  908.         pbox->q.y = min(qy, (int)ceil(ibox.q.y));
  909.       }
  910.     else
  911.       { /*
  912.          * The inverse transform of the band is not aligned with the
  913.          * axes, i.e., is a general parallelogram.  To compute an exact
  914.          * bounding box, we need to find the intersections of this
  915.          * parallelogram with the image subrectangle.
  916.          *
  917.          * There is probably a much more efficient way to do this
  918.          * computation, but we don't know what it is.
  919.          */
  920.         gs_point rect[4];
  921.         gs_point corners[5];
  922.         int i;
  923.  
  924.         /* Store the corners of the image rectangle. */
  925.         rect[0].x = rect[3].x = px;
  926.         rect[1].x = rect[2].x = qx;
  927.         rect[0].y = rect[1].y = py;
  928.         rect[2].y = rect[3].y = qy;
  929.         /* Compute the corners of the clipped band in image space. */
  930.         gs_point_transform_inverse(bbox.p.x, bbox.p.y, &pie->matrix,
  931.                        &corners[0]);
  932.         gs_point_transform_inverse(bbox.q.x, bbox.p.y, &pie->matrix,
  933.                        &corners[1]);
  934.         gs_point_transform_inverse(bbox.q.x, bbox.q.y, &pie->matrix,
  935.                        &corners[2]);
  936.         gs_point_transform_inverse(bbox.p.x, bbox.q.y, &pie->matrix,
  937.                        &corners[3]);
  938.         corners[4] = corners[0];
  939.         pbox->p.x = qx, pbox->p.y = qy;
  940.         pbox->q.x = px, pbox->q.y = py;
  941.         /*
  942.          * We iterate over both the image rectangle and the band
  943.          * parallelogram in a single loop for convenience, even though
  944.          * there is no coupling between the two.
  945.          */
  946.         for ( i = 0; i < 4; ++i )
  947.           { gs_point pa, pt;
  948.             double dx, dy;
  949.  
  950.         /* Check the image corner for being inside the band. */
  951.         pa = rect[i];
  952.         gs_point_transform(pa.x, pa.y, &pie->matrix, &pt);
  953.         if ( pt.x >= bbox.p.x && pt.x <= bbox.q.x &&
  954.              pt.y >= bbox.p.y && pt.y <= bbox.q.y
  955.            )
  956.           box_merge_point(pbox, pa.x, pa.y);
  957.         /* Check the band corner for being inside the image. */
  958.             pa = corners[i];
  959.         if ( pa.x >= px && pa.x <= qx && pa.y >= py && pa.y <= qy )
  960.           box_merge_point(pbox, pa.x, pa.y);
  961.         /* Check for intersections of band edges with image edges. */
  962.         dx = corners[i+1].x - pa.x;
  963.         dy = corners[i+1].y - pa.y;
  964. #define in_range(t, tc, p, q)\
  965.   (0 <= t && t <= 1 && (t = tc) >= p && t <= q)
  966.         if ( dx != 0 )
  967.           { double t = (px - pa.x) / dx;
  968.  
  969.             if_debug3('b', "   (px) t=%g => (%d,%g)\n",
  970.                   t, px, pa.y + t * dy);
  971.             if ( in_range(t, pa.y + t * dy, py, qy) )
  972.               box_merge_point(pbox, (floatp)px, t);
  973.             t = (qx - pa.x) / dx;
  974.             if_debug3('b', "   (qx) t=%g => (%d,%g)\n",
  975.                   t, qx, pa.y + t * dy);
  976.             if ( in_range(t, pa.y + t * dy, py, qy) )
  977.               box_merge_point(pbox, (floatp)qx, t);
  978.           }
  979.         if ( dy != 0 )
  980.           { double t = (py - pa.y) / dy;
  981.  
  982.             if_debug3('b', "   (py) t=%g => (%g,%d)\n",
  983.                   t, pa.x + t * dx, py);
  984.             if ( in_range(t, pa.x + t * dx, px, qx) )
  985.               box_merge_point(pbox, t, (floatp)py);
  986.             t = (qy - pa.y) / dy;
  987.             if_debug3('b', "   (qy) t=%g => (%g,%d)\n",
  988.                   t, pa.x + t * dx, qy);
  989.             if ( in_range(t, pa.x + t * dx, px, qx) )
  990.               box_merge_point(pbox, t, (floatp)qy);
  991.           }
  992. #undef in_range
  993.           }
  994.       }
  995.     if_debug4('b', "    => (%d,%d),(%d,%d)\n", pbox->p.x, pbox->p.y,
  996.           pbox->q.x, pbox->q.y);
  997. #ifdef FUTURE
  998.     /*
  999.      * If necessary, add pixels around the edges so we will have
  1000.      * enough information to do interpolation.
  1001.      */
  1002.     if ( (pbox->p.x -= pie->support.x) < pie->rect.p.x )
  1003.       pbox->p.x = pie->rect.p.x;
  1004.     if ( (pbox->p.y -= pie->support.y) < pie->rect.p.y )
  1005.       pbox->p.y = pie->rect.p.y;
  1006.     if ( (pbox->q.x += pie->support.x) > pie->rect.q.x )
  1007.       pbox->q.x = pie->rect.q.x;
  1008.     if ( (pbox->q.y += pie->support.y) > pie->rect.q.y )
  1009.       pbox->q.y = pie->rect.q.y;
  1010. #endif
  1011.     return (pbox->p.x < pbox->q.x && pbox->p.y < pbox->q.y);
  1012. }
  1013.  
  1014. /* Write data for a partial image. */
  1015. private int
  1016. cmd_image_data(gx_device_clist_writer *cldev, gx_clist_state *pcls,
  1017.   const byte **planes, int num_planes, uint offset, int data_x, uint raster,
  1018.   uint bytes_per_plane, int h)
  1019. {    uint nbytes = bytes_per_plane * num_planes * h;
  1020.     uint len = 1 + cmd_size2w(h, bytes_per_plane) + nbytes;
  1021.     byte *dp;
  1022.     int plane, i;
  1023.  
  1024.     if ( data_x )
  1025.       { set_cmd_put_op(dp, cldev, pcls, cmd_opv_set_misc, 2);
  1026.         dp[1] = cmd_set_misc_data_x + (data_x & 7);
  1027.         offset += ((data_x & ~7) * cldev->color_info.depth) >> 3;
  1028.       }
  1029.     set_cmd_put_op(dp, cldev, pcls, cmd_opv_image_data, len);
  1030.     dp++;
  1031.     cmd_put2w(h, bytes_per_plane, dp);
  1032.     for ( plane = 0; plane < num_planes; ++plane )
  1033.       for ( i = 0; i < h; ++i )
  1034.         { memcpy(dp, planes[plane] + i * raster + offset, bytes_per_plane);
  1035.           dp += bytes_per_plane;
  1036.         }
  1037.     return 0;
  1038. }
  1039.